<!DOCTYPE HTML>
<!--[if lt IE 7]><html class="no-js lt-ie9 lt-ie8 lt-ie7"><![endif]-->
<!--[if IE 7]><html class="no-js lt-ie9 lt-ie8"><![endif]-->
<!--[if IE 8]><html class="no-js lt-ie9"><![endif]-->
<!--[if gt IE 8]><!--><html class="no-js"><!--<![endif]-->
<head>
	<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
	<meta name="viewport" content="width=device-width, initial-scale = 1.0, user-scalable = no">

	<title>Patrones de Diseño</title>

	<!--link href='http://fonts.googleapis.com/css?family=Open+Sans:400,700,600' rel='stylesheet' type='text/css'-->

	<link rel="stylesheet" href="css/normalize.css" type="text/css" media="screen">
	<link rel="stylesheet" href="css/grid.css" type="text/css" media="screen">
	<link rel="stylesheet" href="css/style.css" type="text/css" media="screen">
	<!-- <link rel="stylesheet" href="css/style.min.css" type="text/css" media="screen"> -->
	<!--[if IE]><script src="http://html5shim.googlecode.com/svn/trunk/html5.js"></script><![endif]-->


	<style type="text/css">
#div1 {width:350px;height:70px;padding:10px;border:1px solid #aaaaaa;}
</style>
</head>

<body>
	<div class="menu">
		<div class="container clearfix">

			<div id="logo" class="grid_2">
				<img src="images/logo.png">
			</div>
			<h3 class="logo-title grid_4">Patrones de Diseño Creacionales</h3>
			<div id="nav" class="grid_6 omega">
				<ul class="navigation">
					<li data-slide="1">Inicio</li>
					<li data-slide="2">Lección</li>
					<li data-slide="3">Bibliografía</li>
				</ul>
			</div>
		</div>
		<hr/>
	</div>

	<div class="slide" id="slide1" data-slide="1" data-stellar-background-ratio="0.5">
		<div class="container clearfix">
			<div id="content" class="grid_7">
				<h2>Ingenieria de Software</h2>
				<h1><strong>Patrones de Diseño</strong></h1><p>.</p>
				<h2>Creacionales</h2>
				<h3>Autor(es): Fernando Morales, Luis Zárate</h3>
				<h1> </h1>

				<h2>Objetivos:</h2>
				<ul class="norm_list">
					<li>
						Familiarizarse con los problemas de diseño resueltos por los patrones de diseño cracionales.
					</li>
					<li>
						Adquirir habilidades en la identificación del tipo de problema, si tiene que ver con crear.
					</li>
					<li>
						Entender los beneficios y riesgos en el uso de cada patrón en la solución de problemas diseño.
					</li>
					<li>
						Identificar los distintos patrones creacionales de diseño de software.
					</li>
				</ul>
				<a href="#" data-slide="2" class ="button">Iniciar lección »</a>

			</div>

			<div id="decorative" class="grid_5 omega">
				<img src="images/JavaIcon.png" style="margin-left:80px;"/>
			</div>

		</div>
	</div>

	<div class="slide" id="slide2" data-slide="2" data-stellar-background-ratio="0.5">
		<div class="container clearfix">

			<div id="content" class="grid_12">
				<section class='slides layout-regular template-default'>

					<article>
						<h3>Antes de empezar...</h3>
						<h4 style="margin:0.2em 0">...un repaso</h4>
						<h5 style="margin-top: 0 !important;">Qué es un patrón de diseño?</h5>
						<q>
							Los patrones de diseño son soluciones parciales  a problemas comunes, como la separación de una interfaz con respecto a varias implementaciones alternas, la idea es estandarizar la información sobre un problema común y su solución probada. La utilización de clases mediante la delegación y herencia, proporcionan una solución robusta y modificable que evita la búsqueda de soluciones a problemas ya conocidos y solucionados anteriormente.
						</q>
						<h5 style="margin-top: 0 !important;">Ventajas</h5>
						<ul class="reminder">
							<li>
								Facilita la descomposición de problemas complejos en la abstracción de problemas simples de fácil solución.
							</li>
							<li>Permite la reutilización de código lo cual agiliza los procesos de desarrollo de software.</li>
							<li>El código generado por los desarrollaros es más eficiente.</li>
							<li>Se estandariza la solución a problemas de desarrollo de software comunes.</li>
						</ul>
					</article>

					<article>
						<h3>Antes de empezar...</h3>
						<h5 style="margin-top: 0 !important;">Tipos de patrones de diseño</h5>
						<table style="margin-top:0px;">
							<tr>
								<td style="width:48%;">
									<ul class="reminder">
										<li>
											<strong>Creacionales:</strong>
											se usan para variar y controlar la creación de objetos, estos patrones por lo común crean objetos por medio de un método u objeto separado, en lugar de usar a los constructores directamente.
										</li>
										<li>
											<strong>Estructurales:</strong>
											representan objetos complejos (listas, colecciones y árboles) como objetos con interfaces convenientes
										</li>
										<li>
											<strong>Comportamentales:</strong>
											 encapsulan las opciones de comportamiento de la aplicación y permiten que ese comportamiento varíe durante la ejecución.
										</li>
									</ul>
								</td>
								<td style="vertical-align:middle;">
									<img src="images/lessons/patterns.png"/>
								</td>
							</tr>
						</table>
					</article>

					<article>
						<h3>Patrones Creacionales</h3>
						<table>
							<tr><td style="text-align:center; padding: 30px 0"><img src="images/lessons/creationals.png"/></td></tr>
						</table>
					</article>

					<article>
						<h3>Singleton</h3>
						<table>
							<tr>
								<td style="width:45%;">
									<strong>Nivel:</strong>Clase
								</td>
								<td rowspan="3">
									<strong>Descripcion:</strong>
									<p>
										El Singleton asegura un máximo de una instancia creada por la máquina virtual de Java. Para asegurarse de tener el control sobre la creación de instancias, hacen que el constructor sea privado.
									</p>
									<p>
										Para la creación de una única instancia se genera un método de acceso público y estático (getInstance()), este método es el encargado de crear la instancia si es que aún no existe, el método devuelve la referencia al objeto. La instancia al singleton se almacena como un atributo private static de la clase singleton.
									</p>
									<p>
										Aunque el método de acceso al singleton puede crear el singleton, la mayoría de las veces se crea cuando la clase se carga. El aplazamiento de la construcción sólo es necesario si algún tipo de inicialización se tiene que hacer antes de que se cree una instancia del singleton.
									</p>
								</td>
							</tr>
							<tr>
								<td style="width:45%;">
									<strong>Propósito:</strong>
									Tener una única instancia de una clase en el sistema permitiendo a otras clases el acceso a esta única instancia.
								</td>
							</tr>
							<tr>
								<td style="width:45%;">
									<strong>Aplicabilidad:</strong>
									<p>
										Use el patrón Singleton cuando:
										<ul>
											<li>
												El uso de este patrón es adecuado cuando se requiere un objeto global que pueda se accedido desde cualquier lugar y que deba ser creado tan solo una vez.
											</li>
										</ul>
									</p>
								</td>
							</tr>
						</table>
					</article>

					<article>
						<h3>Singleton</h3>
						<table>
							<tr>
								<td style="width:45%;">
									<strong>Implementación:</strong>
									<ul>
										<li>
											<strong>Clase Singleton:</strong>
											 Proporciona un constructor privado, mantiene una referencia estática privada a la única instancia de la clase, y proporciona un método de acceso estático para devolver una referencia a la instancia única.
										</li>
									</ul>
									<strong>Diagrama de clases (UML):</strong>
									<p><img src="images/lessons/uml-singleton.png"/></p>
								</td>
								<td style="vertical-align:top !important;">
									<strong>Ventajas y Desventajas:</strong>
									<p>
										El Singleton es la única clase que puede crear una instancia de sí mismo. No se puede crear una instancia sin utilizar el método estático proporcionado.
									</p>
									<p>
										No tendrá que pasar la referencia a todos los objetos que necesitan este Singleton.
									</p>
									<p>
										Sin embargo, el patrón Singleton pueden presentar problemas de hilos, dependiendo de la implementación. Hay que tener cuidado en el control de la inicialización Singleton en una aplicación multihilo. Sin el control adecuado, la aplicación ingresará a una "guerra de hilos".
									</p>
								</td>
							</tr>
						</table>
					</article>

					<article>
						<h3>Singleton</h3>
						<h5 style="margin-top: 0 !important;">Codificación en Java</h5>
						<p>Clase Singleton.java</p>
						<pre>
package com.gis.uptc.patrones.creacional.singleton;

/**
 * <b>Universidad Pedagógica y Tecnológica de Colombia</b>
 * <b>Facultad de Ingeniería - Escuela de Sistemas y Computación</b>
 * <b>Grupo de Investigación en Software(GIS) </b>
 * Clase que representa el patron de diseño Singleton
 *
 * @author Luis Arturo Zárate Ayala <luisarturo1989@gmail.com>
 * @author Wilson Fernando Morales Torres <ferchomt99@gmail.com>
 */
public class Singleton {

	/**
	 * Atributo que almacen al instancia de la clase Singleton
	 */
	private static Singleton instance = new Singleton();

	/**
	 * Método Constructor
	 */
	private Singleton() {
	}

	/**
	 * Método que obtiene el valor de la variable instance
	 * @return valor de la variable instance
	 */
	public static Singleton getInstance() {
		return instance;
	}

}
						</pre>
					</article>

					<article>
						<h3>Factory Method (método de fábrica)</h3>
						<table style="letter-spacing: -1px;">
							<tr>
								<td style="width:45%;">
									<strong>Nivel:</strong>Clase
								</td>
								<td rowspan="3">
									<strong>Descripcion:</strong>
									<p>
										Este patrón se llama Factory Method, ya que crea objetos cuando usted lo desee.
									</p>
									<p>
										Cuando empieza a escribir una aplicación, no es a menudo claro qué tipo de componentes va a utilizar. Normalmente, tendrá una idea general de las operaciones que ciertos componentes deben tener, pero la implementación se lleva a cabo en otro momento.
									</p>
									<p>
										Esta flexibilidad se puede lograr mediante el uso de interfaces para estos componentes. Pero el problema con la programación de las interfaces es que no se puede crear un objeto a partir de una interfaz. Usted necesita una clase de implementación para obtener un objeto.  En lugar de codificar una clase de implementación específica, se extrae la funcionalidad del constructor y lo pone en un método. Este método es el método de fábrica.
									</p>
									<p>
										Para crear estos objetos, en lugar de codificar una clase específica de aplicación, se extrae la funcionalidad del constructor y  se pone en un método. Esto produce un ConcreteCreator cuya responsabilidad es crear los objetos adecuados.
									</p>
								</td>
							</tr>
							<tr>
								<td style="width:45%;">
									<strong>Propósito:</strong>
									Define un método estándar para crear un objeto, aparte del constructor, pero la decisión de qué tipo de objeto a crear se deja a las subclases.
								</td>
							</tr>
							<tr>
								<td style="width:45%;">
									<strong>Aplicabilidad:</strong>
									<p>
										Use el patrón Factory Method cuando:
										<ul>
											<li>
												Desee crear un framework extensible. Esto significa permitir flexibilidad al dejar algunas decisiones para más tarde, como lo es el tipo específico de objeto a crear.
											</li>
											<li>
												Desea una subclase, en lugar de su superclase, para decidir qué tipo de objeto a crear.
											</li>
											<li>
												Sabe cuándo crear un objeto, pero no el tipo de objeto.
											</li>
											<li>
												Necesita varios constructores sobrecargados con la misma lista de parámetros, esto no está permitido en Java. En su lugar, utilizar varios métodos de fábrica con diferentes nombres.
											</li>
										</ul>
									</p>
								</td>
							</tr>
						</table>
					</article>

					<article>
						<h3>Factory Method (método de fábrica)</h3>
						<table>
							<tr>
								<td style="width:45%;">
									<strong>Implementación:</strong>
									<ul>
										<li>
											<strong>Interfaz Product:</strong>
											La interfaz de los objetos creados por la fábrica.
										</li>
										<li>
											<strong>Clase ConcreteProduct:</strong>
											La clase de implementación del producto. Los objetos de esta clase son creados por el ConcreteCreator.
										</li>
										<li>
											<strong>Interfaz Creator:</strong>
											La interfaz que define el método de fábrica (factoryMethod).
										</li>
										<li>
											<strong>Clase ConcreteCreator: </strong>
											La clase que extiende a Creator y que proporciona una implementación para el factoryMethod. Esto puede devolver cualquier objeto que implemente la interfaz del producto.
										</li>
									</ul>
								</td>
								<td style="vertical-align:top !important;">
									<strong>Diagrama de clases (UML):</strong>
									<p><img src="images/lessons/uml-factMeth.png"/></p>
								</td>
							</tr>
						</table>
					</article>

					<article>
						<h3>Factory Method (método de fábrica)</h3>
						<table>
							<tr>
								<td style="vertical-align:top !important;">
									<strong>Ventajas y Desventajas:</strong>
									<p>
										Hace más fácil añadir nuevos tipos de información a manejar sin cambiar el núcleo del programa.
 									</p>
									<p>
										JDBC (Java Database Connectivity) utiliza el patrón Factory Method en muchas de sus interfaces. Puede utilizar otro driver JDBC, siempre y cuando el controlador correcto está cargado. El resto de su aplicación sigue siendo la misma.
									</p>
									<p>
										El inconveniente de este modelo es el hecho de que al añadir un nuevo tipo de producto, se debe añadir otra una nueva clase ConcreteProduct, y debe cambiar un ConcreteCreator existente, o crear una nueva clase que implemente el producto.
									</p>
								</td>
							</tr>
						</table>
					</article>

					<article>
						<h3>Factory Method (método de fábrica)</h3>
						<h5 style="margin-top: 0 !important;">Codificación en Java</h5>
						<p>Interfaz Creator.java</p>
						<pre>
package com.gis.uptc.patrones.creacional.factoryMethod;

/**
 * <b>Universidad Pedagógica y Tecnológica de Colombia</b>
 * <b>Facultad de Ingeniería - Escuela de Sistemas y Computación</b>
 * <b>Grupo de Investigación en Software(GIS) </b>
 * Interfaz que representa el <b>Creator</b> del patron de diseño
 * <b>FactoryMethod</b>
 *
 * @author Luis Arturo Zárate Ayala
 * @author Wilson Fernando Morales Torres
 */
public interface Creator {

	/**
	 * Método abstracto que permitirá la creación de un <b>ConcreteProduct</b>
	 *
	 * @return <b>ConcreteProduct</b>, un producto concreto
	 */
	Product factoryMethod();

}
						</pre>
					</article>

					<article>
						<h3>Factory Method (método de fábrica)</h3>
						<h5 style="margin-top: 0 !important;">Codificación en Java</h5>
						<p>Interfaz Product.java</p>
						<pre>
package com.gis.uptc.patrones.creacional.factoryMethod;

/**
 * <b>Universidad Pedagógica y Tecnológica de Colombia</b>
 * <b>Facultad de Ingeniería - Escuela de Sistemas y Computación</b>
 * <b>Grupo de Investigación en Software(GIS) </b>
 * Interfaz que representa el <b>Product</b> del patron de diseño
 * <b>FactoryMethod</b>
 *
 * @author Luis Arturo Zárate Ayala
 * @author Wilson Fernando Morales Torres
 */
public interface Product {

	/**
	 * Método abstracto ejecutará una determinada operación en el producto
	 */
	void operation();

}
						</pre>
					</article>

					<article>
						<h3>Factory Method (método de fábrica)</h3>
						<h5 style="margin-top: 0 !important;">Codificación en Java</h5>
						<p>Clase ConcreteProduct.java</p>
						<pre>
package com.gis.uptc.patrones.creacional.factoryMethod;

/**
 * <b>Universidad Pedagógica y Tecnológica de Colombia</b>
 * <b>Facultad de Ingeniería - Escuela de Sistemas y Computación</b>
 * <b>Grupo de Investigación en Software(GIS) </b>
 * Clase que ejemplifica los <b>ConcreteProduct</b> del patron de diseño
 * <b>FactoryMethod</b>
 *
 * @author Luis Arturo Zárate Ayala
 * @author Wilson Fernando Morales Torres
 */
public class ConcreteProduct implements Product{

	@Override
	public void operation() {
		System.out.println("Una operación de este producto");
	}

}
						</pre>
					</article>

					<article>
						<h3>Factory Method (método de fábrica)</h3>
						<h5 style="margin-top: 0 !important;">Codificación en Java</h5>
						<p>Clase ConcreteCreator.java</p>
						<pre>
package com.gis.uptc.patrones.creacional.factoryMethod;

/**
 * <b>Universidad Pedagógica y Tecnológica de Colombia</b>
 * <b>Facultad de Ingeniería - Escuela de Sistemas y Computación</b>
 * <b>Grupo de Investigación en Software(GIS) </b>
 * Clase que representa el <b>ConcreteCreator</b> del patron de diseño
 * <b>FactoryMethod</b>
 *
 * @author Luis Arturo Zárate Ayala
 * @author Wilson Fernando Morales Torres
 */
public class ConcreteCreator implements Creator{

	@Override
	public Product factoryMethod() {
		return new ConcreteProduct();
	}

}

						</pre>
					</article>

					<article>
						<h3>Abstract Factory (fábrica abstracta)</h3>
						<table>
							<tr>
								<td style="width:45%;">
									<strong>Nivel:</strong>Componente
								</td>
							</tr>
							<tr>
								<td style="width:45%;">
									<strong>Propósito:</strong>
									Ofrecer un contrato para crear familias de objetos relacionados o dependientes sin tener que especificar sus clases concretas.
								</td>
							</tr>
							<tr>
								<td style="width:45%;">
									<strong>Aplicabilidad:</strong>
									<p>
										Utilice el patrón Abstract Factory cuando:
										<ul>
											<li>
												El cliente es independiente de la forma en que los productos son creados.
											</li>
											<li>
												La aplicación debería ser configurado con una de múltiples familias de productos.
											</li>
											<li>
												Los Objetos necesitan ser creados como un conjunto, con el fin de ser compatibles.
											</li>
											<li>
												Desea proporcionar una colección de clases y desea revelar sólo sus contratos y sus relaciones, no sus implementaciones.
											</li>
										</ul>
									</p>
								</td>
							</tr>
						</table>
					</article>

					<article>
						<h3>Abstract Factory (fábrica abstracta)</h3>
						<table>
							<tr>
								<td rowspan="3">
									<strong>Descripcion:</strong>
									<p>
										A veces, una aplicación necesita utilizar una variedad de recursos diferentes o entornos operativos.
									</p>
									<p>
										En este tipo de aplicación usted desea hacer la aplicación lo suficientemente flexible como para utilizar una variedad de  recursos sin tener que recodificar la aplicación cada vez que se introduce un nuevo recurso.
									</p>
									<p>
										Una manera efectiva para solucionar este problema es definir un recurso genérico un creador, la fábrica abstracta. La fábrica cuenta con uno o más métodos creadores, que pueden ser llamados a producir los recursos genéricos o productos abstractos.
									</p>
									<p>
										Java se ejecuta en muchas plataformas, cada una con muchas implementaciones diferentes de un sistema de archivos o ventanas. La solución que Java ha tomado es abstraer los conceptos de archivos y ventanas y no mostrar la aplicación concreta. Usted puede desarrollar la aplicación utilizando las capacidades genéricas de los recursos como si representaran la funcionalidad real.
									</p>
									<p>
										Durante el tiempo de ejecución, los ConcreteFactories y ConcreteProducts son creados y utilizados por la aplicación. Las clases concretas conforman el contrato definido por el AbstractFactory y AbstractProducts, por lo que las clases concretas se pueden usar directamente, sin ser recodificada o recompilado.
									</p>
								</td>
							</tr>
						</table>
					</article>

					<article>
						<h3>Abstract Factory (fábrica abstracta)</h3>
						<table>
							<tr>
								<td style="vertical-align:top !important;">
									<strong>Diagrama de clases (UML):</strong>
									<p style="width:75%; margin: auto;"><img src="images/lessons/uml-absFact.png"/></p>
								</td>
							</tr>
						</table>
					</article>

					<article>
						<h3>Abstract Factory (fábrica abstracta)</h3>
						<table>
							<tr>
								<td style="vertical-align:top !important;">
									<strong>Ventajas y Desventajas:</strong>
									<p>
										Un Abstract Factory ayuda a aumentar la flexibilidad general de una aplicación. Esta flexibilidad se manifiesta tanto en tiempo de diseño y tiempo de ejecución. Durante el diseño, usted no tiene que predecir todos los usos futuros de una aplicación. En su lugar, se crea el marco genérico y luego desarrollar implementaciones de forma independiente del resto de la aplicación. En tiempo de ejecución, la aplicación se puede integrar fácilmente nuevas funciones y recursos.
 									</p>
									<p>
										Un beneficio adicional de este modelo es que se puede simplificar probando el resto de la aplicación. La implementación de un TestConcreteFactory y TestConcreteProduct es simple, puede simular el comportamiento de los recursos previstos.
									</p>
									<p>
										Para obtener los beneficios de este patrón, considere cuidadosamente cómo definir una interfaz genérica para el producto abstracto. Si el producto no está bien definido, la producción de algunos de los productos concretos puede ser difícil o imposible.
									</p>
								</td>
							</tr>
						</table>
					</article>

					<article>
						<h3>Abstract Factory (fábrica abstracta)</h3>
						<h5 style="margin-top: 0 !important;">Codificación en Java</h5>
						<p>Interfaz AbstractFactory.java</p>
						<pre>
package com.gis.uptc.patrones.creacional.abstractFactory;

/**
 * <b>Universidad Pedagógica y Tecnológica de Colombia</b>
 * <b>Facultad de Ingeniería - Escuela de Sistemas y Computación</b>
 * <b>Grupo de Investigación en Software(GIS) </b>
 * Interfaz que representa el patron de diseño <b>AbstracFactory</b>
 *
 * @author Luis Arturo Zárate Ayala
 * @author Wilson Fernando Morales Torres
 */
public interface AbstractFactory {

	/**
	 * Método encargado de crear un producto de tipo A
	 * @return ProductA, nuevo producto de tipo A
	 */
	ProductA createProductA();

	/**
	 * Método encargado de crear un producto de tipo B
	 * @return ProductB, nuevo producto de tipo B
	 */
	ProductB createProductB();
}


						</pre>
					</article>

					<article>
						<h3>Abstract Factory (fábrica abstracta)</h3>
						<h5 style="margin-top: 0 !important;">Codificación en Java</h5>
						<p>Clase ConcreteFactory1.java</p>
						<pre>
package com.gis.uptc.patrones.creacional.abstractFactory;

/**
 * <b>Universidad Pedagógica y Tecnológica de Colombia</b>
 * <b>Facultad de Ingeniería - Escuela de Sistemas y Computación</b>
 * <b>Grupo de Investigación en Software(GIS) </b>
 * Clase que representa el <b>ConcreteFactory1</b> del patron de diseño
 * <b>AbstractFactory</b>
 *
 * @author Luis Arturo Zárate Ayala
 * @author Wilson Fernando Morales Torres
 */
public class ConcreteFactory1 implements AbstractFactory{

	@Override
	public ProductA createProductA() {
		return new ConcreteProductA1();
	}

	@Override
	public ProductB createProductB() {
		return new ConcreteProductB1();
	}

}


						</pre>
					</article>

					<article>
						<h3>Abstract Factory (fábrica abstracta)</h3>
						<h5 style="margin-top: 0 !important;">Codificación en Java</h5>
						<p>Clase ConcreteFactory2.java</p>
						<pre>
package com.gis.uptc.patrones.creacional.abstractFactory;

/**
 * <b>Universidad Pedagógica y Tecnológica de Colombia</b>
 * <b>Facultad de Ingeniería - Escuela de Sistemas y Computación</b>
 * <b>Grupo de Investigación en Software(GIS) </b>
 * Clase que representa el <b>ConcreteFactory2</b> del patron de diseño
 * <b>AbstractFactory</b>
 *
 * @author Luis Arturo Zárate Ayala
 * @author Wilson Fernando Morales Torres
 */
public class ConcreteFactory2 implements AbstractFactory{

	@Override
	public ProductA createProductA() {
		return new ConcreteProductA2();
	}

	@Override
	public ProductB createProductB() {
		return new ConcreteProductB2();
	}

}


						</pre>
					</article>

					<article>
						<h3>Abstract Factory (fábrica abstracta)</h3>
						<h5 style="margin-top: 0 !important;">Codificación en Java</h5>
						<p>Clase ProductA.java</p>
						<pre>
package com.gis.uptc.patrones.creacional.abstractFactory;

/**
 * <b>Universidad Pedagógica y Tecnológica de Colombia</b>
 * <b>Facultad de Ingeniería - Escuela de Sistemas y Computación</b>
 * <b>Grupo de Investigación en Software(GIS) </b>
 * Clase que representa el <b>ProductA</b> del patron de diseño
 * <b>AbstractFactory</b>
 *
 * @author Luis Arturo Zárate Ayala
 * @author Wilson Fernando Morales Torres
 */
public class ProductA {
	//TODO En este espacio se definen atributos y métodos del Producto A
}

						</pre>
					</article>

					<article>
						<h3>Abstract Factory (fábrica abstracta)</h3>
						<h5 style="margin-top: 0 !important;">Codificación en Java</h5>
						<p>Clase ProductB.java</p>
						<pre>
package com.gis.uptc.patrones.creacional.abstractFactory;

/**
 * <b>Universidad Pedagógica y Tecnológica de Colombia</b>
 * <b>Facultad de Ingeniería - Escuela de Sistemas y Computación</b>
 * <b>Grupo de Investigación en Software(GIS) </b>
 * Clase que representa el <b>ProductB</b> del patron de diseño
 * <b>AbstractFactory</b>
 *
 * @author Luis Arturo Zárate Ayala
 * @author Wilson Fernando Morales Torres
 */
public class ProductB {
	//TODO En este espacio se definen atributos y métodos del Producto B
}




						</pre>
					</article>

					<article>
						<h3>Abstract Factory (fábrica abstracta)</h3>
						<h5 style="margin-top: 0 !important;">Codificación en Java</h5>
						<p>Clase ConcreteProductA1.java</p>
						<pre>
package com.gis.uptc.patrones.creacional.abstractFactory;

/**
 * <b>Universidad Pedagógica y Tecnológica de Colombia</b>
 * <b>Facultad de Ingeniería - Escuela de Sistemas y Computación</b>
 * <b>Grupo de Investigación en Software(GIS) </b>
 * Clase que representa el <b>ConcreteProductA1</b> del patron de diseño
 * <b>AbstractFactory</b>
 *
 * @author Luis Arturo Zárate Ayala
 * @author Wilson Fernando Morales Torres
 */
public class ConcreteProductA1 extends ProductA{
	//TODO En este espacio se definen atributos y métodos del ConcreteProductA1
}


						</pre>
					</article>

					<article>
						<h3>Abstract Factory (fábrica abstracta)</h3>
						<h5 style="margin-top: 0 !important;">Codificación en Java</h5>
						<p>Clase ConcreteProductA2.java</p>
						<pre>
package com.gis.uptc.patrones.creacional.abstractFactory;

/**
 * <b>Universidad Pedagógica y Tecnológica de Colombia</b>
 * <b>Facultad de Ingeniería - Escuela de Sistemas y Computación</b>
 * <b>Grupo de Investigación en Software(GIS) </b>
 * Clase que representa el <b>ConcreteProductA2</b> del patron de diseño
 * <b>AbstractFactory</b>
 *
 * @author Luis Arturo Zárate Ayala
 * @author Wilson Fernando Morales Torres
 */
public class ConcreteProductA2 extends ProductA{
	//TODO En este espacio se definen atributos y métodos del ConcreteProductA2
}




						</pre>
					</article>

					<article>
						<h3>Abstract Factory (fábrica abstracta)</h3>
						<h5 style="margin-top: 0 !important;">Codificación en Java</h5>
						<p>Clase ConcreteProductB1.java</p>
						<pre>
package com.gis.uptc.patrones.creacional.abstractFactory;

/**
 * <b>Universidad Pedagógica y Tecnológica de Colombia</b>
 * <b>Facultad de Ingeniería - Escuela de Sistemas y Computación</b>
 * <b>Grupo de Investigación en Software(GIS) </b>
 * Clase que representa el <b>ConcreteProductB1</b> del patron de diseño
 * <b>AbstractFactory</b>
 *
 * @author Luis Arturo Zárate Ayala
 * @author Wilson Fernando Morales Torres
 */
public class ConcreteProductB1 extends ProductB{
	//TODO En este espacio se definen atributos y métodos del ConcreteProductB1
}

						</pre>
					</article>

					<article>
						<h3>Abstract Factory (fábrica abstracta)</h3>
						<h5 style="margin-top: 0 !important;">Codificación en Java</h5>
						<p>Clase ConcreteProductB2.java</p>
						<pre>
package com.gis.uptc.patrones.creacional.abstractFactory;

/**
 * <b>Universidad Pedagógica y Tecnológica de Colombia</b>
 * <b>Facultad de Ingeniería - Escuela de Sistemas y Computación</b>
 * <b>Grupo de Investigación en Software(GIS) </b>
 * Clase que representa el <b>ConcreteProductB2</b> del patron de diseño
 * <b>AbstractFactory</b>
 *
 * @author Luis Arturo Zárate Ayala
 * @author Wilson Fernando Morales Torres
 */
public class ConcreteProductB2 extends ProductB{
	//TODO En este espacio se definen atributos y métodos del ConcreteProductB2
}
						</pre>
					</article>

					<article>
						<h3>Builder (Constructor)</h3>
						<table>
							<tr>
								<td style="width:45%;">
									<strong>Nivel:</strong>Componente
								</td>
							</tr>
							<tr>
								<td style="width:45%;">
									<strong>Propósito:</strong>
									Simplificar la creación de objetos complejos mediante la definición de una clase cuyo propósito es crear instancias de otra clase. El patrón Builder produce un producto principal, de tal manera que podría haber más de una clase en el producto, pero siempre debe existir una clase principal.
								</td>
							</tr>
							<tr>
								<td style="width:45%;">
									<strong>Aplicabilidad:</strong>
									<p>
										Use el patrón Builder, cuando una clase:
										<ul>
											<li>
												Tiene estructura interna compleja (especialmente si la estructura contiene un conjunto de variables de objetos relacionados).
											</li>
											<li>
												Tiene atributos que dependen unos de otros. Una de las cosas que un constructor puede hacer es hacer cumplir la construcción por etapas de un objeto complejo. Esto se requiere cuando los atributos del producto dependen uno del otro. Por ejemplo, supongamos que usted está construyendo un orden de envíos. Puede que tenga que asegurarse que la orden tenga un estado antes de ejecutar el método de envío, ya que el estado tendría un impacto del impuesto sobre las ventas que aplica a la propia Orden.
											</li>
											<li>
												Utiliza otros objetos en el sistema que puede presentar dificultad o inconvenientes para obtención durante la creación.
											</li>
										</ul>
									</p>
								</td>
							</tr>
						</table>
					</article>

					<article>
						<h3>Builder (Constructor)</h3>
						<table>
							<tr>
								<td rowspan="3">
									<strong>Descripcion:</strong>
									<p>
										Abstrae el proceso de creación de un objeto complejo, centralizando dicho proceso en un único punto, de tal forma que el mismo proceso de construcción pueda crear representaciones diferentes.
									</p>
									<p>
										Los objetos de negocio a menudo caen en esta categoría. Con frecuencia se requieren los datos de una base de datos para la inicialización, se deben asociar objetos de negocio para representar con precisión el modelo de negocio. Otro ejemplo es el de objetos compuestos en un sistema, tal como un objeto representado a modo de dibujo en un programa de edición visual. Tal objeto puede ser que necesite estar relacionada con un número arbitrario de otros objetos tan pronto como se crea.
									</p>
									<p>
										En casos como los anteriormente descritos, es conveniente definir otra clase (Builder) que es responsable de la construcción. El Constructor coordina el conjunto del objeto de producto: la creación de recursos, almacenar resultados intermedios y proporcionar una estructura funcional para la creación. Además, el constructor puede adquirir los recursos del sistema necesarios para la construcción del producto.
									</p>
								</td>
							</tr>
						</table>
					</article>

					<article>
						<h3>Builder (Constructor)</h3>
						<table>
							<tr>
								<td style="width:45%;">
									<strong>Implementación:</strong>
									<ul>
										<li>
											<strong>Clase Director: </strong>
											 tiene una referencia a una instancia AbstractBuilder. El Director llama a los métodos creacionales en su instancia constructor para tener las diferentes partes y construir el Constructor.
										</li>
										<li>
											<strong>Interfaz AbstractBuilder: </strong>
											La interfaz que define los métodos disponibles para crear las partes separadas del producto.
										</li>
										<li>
											<strong>Clase ConcreteBuilder: </strong>
											Implementa la interfaz AbstractBuilder. El ConcreteBuilder implementa todos los métodos necesarios para crear un producto real. La puesta en práctica de los métodos sabe cómo procesar la información del director y construir las respectivas partes de un producto. El ConcreteBuilder también tiene o bien un método o un método obtenerProducto creacional para devolver la instancia del producto
										</li>
									</ul>
								</td>
								<td style="vertical-align:top !important;">
									<strong>Diagrama de clases (UML):</strong>
									<p><img src="images/lessons/uml-builder.png"/></p>
								</td>
							</tr>
						</table>
					</article>

					<article>
						<h3>Builder (Constructor)</h3>
						<table>
							<tr>
								<td style="vertical-align:top !important;">
									<strong>Ventajas y Desventajas:</strong>
									<p>
										El patrón Builder hace que sea más fácil de manejar el flujo global durante la creación de objetos complejos. Esto se manifiesta de dos maneras:
										<ul>
											<li>
												Para los objetos que requieren la creación por etapas (una secuencia de pasos para hacer el objeto completamente activo). El constructor actúa como un objeto más alto nivel para supervisar el proceso. Se puede coordinar y validar la creación de todos los recursos y si es necesario proporcionar una estrategia de recuperación en caso de errores.
											</li>
											<li>
												Para los objetos que necesitan recursos existentes del sistema durante la creación (como las conexiones de base de datos o los objetos existentes de negocios),  El constructor proporciona un único punto de control creacional de su producto, qué otros objetos dentro del sistema pueden utilizar.
											</li>
										</ul>
 									</p>
									<p>
										El principal inconveniente de este patrón es que existe un acoplamiento ajustado entre el creador, producto, y los otros delegados creacionales utilizados durante la construcción de objetos. Los cambios generados para el producto creado por el patrón Builder suelen dar lugar a modificaciones, tanto para el constructor y sus delegados.
									</p>
								</td>
							</tr>
						</table>
					</article>

					<article>
						<h3>Builder (Constructor)</h3>
						<h5 style="margin-top: 0 !important;">Codificación en Java</h5>
						<p>Clase Director.java</p>
						<pre>
package com.gis.uptc.patrones.creacional.builder;

/**
 * <b>Universidad Pedagógica y Tecnológica de Colombia</b>
 * <b>Facultad de Ingeniería - Escuela de Sistemas y Computación</b>
 * <b>Grupo de Investigación en Software(GIS) </b>
 * Clase que representa el <b>Director</b> del patron de diseño
 * <b>Builder</b>
 *
 * @author Luis Arturo Zárate Ayala
 * @author Wilson Fernando Morales Torres
 */
public class Director {

	/**
	 * Atributo que representa los diferentes constructores de instancias
	 */
	private AbstractBuilder [] builders;

	/**
	 * Método constructor
	 */
	public Director() {
		build();
	}

	/**
	 * Método que construye los objetos del sistema
	 */
	public void build(){
		for (int i = 0; builders!=null && i < builders.length; i++) {
			builders[i].buildProduct();
			builders[i].buildPart();
		}
	}
}
						</pre>
					</article>

					<article>
						<h3>Builder (Constructor)</h3>
						<h5 style="margin-top: 0 !important;">Codificación en Java</h5>
						<p>Interfaz AbstractBuilder.java</p>
						<pre>
package com.gis.uptc.patrones.creacional.builder;

/**
 * <b>Universidad Pedagógica y Tecnológica de Colombia</b>
 * <b>Facultad de Ingeniería - Escuela de Sistemas y Computación</b>
 * <b>Grupo de Investigación en Software(GIS) </b>
 * Interfaz que representa el <b>AbstractBuilder</b> del patron de diseño
 * <b>Builder</b>
 *
 * @author Luis Arturo Zárate Ayala
 * @author Wilson Fernando Morales Torres
 */
public interface AbstractBuilder {

	/**
	 * Método que construye la instancia del producto
	 */
	void buildProduct();

	/**
	 * Método que construte el contenido del producto
	 */
	void buildPart();

}
						</pre>
					</article>

					<article>
						<h3>Builder (Constructor)</h3>
						<h5 style="margin-top: 0 !important;">Codificación en Java</h5>
						<p>Class ConcreteBuilder.java</p>
						<pre>
package com.gis.uptc.patrones.creacional.builder;

/**
 * <b>Universidad Pedagógica y Tecnológica de Colombia</b>
 * <b>Facultad de Ingeniería - Escuela de Sistemas y Computación</b>
 * <b>Grupo de Investigación en Software(GIS) </b>
 * Clase que representa el <b>ConcreteBuilder</b> del patron de diseño
 * <b>Builder</b>
 *
 * @author Luis Arturo Zárate Ayala
 * @author Wilson Fernando Morales Torres
 */
public class ConcreteBuilder implements AbstractBuilder{

	/**
	 * Atributo que almacena el producto a construir
	 */
	private Product producto;

	@Override
	public void buildProduct() {
		producto = new Product();
	}

	@Override
	public void buildPart() {
		// TODO se invoca los metodos setter de los productos
	}

	/**
	 * Método que obtiene el valor de la variable producto
	 * @return valor de la variable producto
	 */
	public Product getProducto() {
		return producto;
	}
}
						</pre>
					</article>

					<article>
						<h3>Builder (Constructor)</h3>
						<h5 style="margin-top: 0 !important;">Codificación en Java</h5>
						<p>Class Product.java</p>
						<pre>
package com.gis.uptc.patrones.creacional.builder;

/**
 * <b>Universidad Pedagógica y Tecnológica de Colombia</b>
 * <b>Facultad de Ingeniería - Escuela de Sistemas y Computación</b>
 * <b>Grupo de Investigación en Software(GIS) </b>
 * Clase que representa el <b>Product</b> del patron de diseño
 * <b>Builder</b>
 *
 * @author Luis Arturo Zárate Ayala
 * @author Wilson Fernando Morales Torres
 */
public class Product {

	//TODO En este espacio se definen las variables y metodos de la clase
}

						</pre>
					</article>

				</section>
			</div>

		</div>
	</div>


	<div class="slide" id="slide4" data-slide="3" data-stellar-background-ratio="1" style="background:#143886;">
	<div class="slide" id="slide4" data-slide="3" data-stellar-background-ratio="0.5">
		<div class="container clearfix" style="padding:260px 0 100px;">

			<div id="content" class="grid_12">
				<h1>Bibliografía</h1>
				<h2>Bernd Bruegge, Allen H. Dutoit</h2>
				<h3>
					<a href="http://isbndb.com/d/book/object_oriented_software_engineering_conquering_complex_and_.html" target="_blank">
						Ingeniería De Software Orientada A Objetos
					</a>
					 Pearson Education, 2002
				</h3>
				<h2></h2>
				<h2>Eric J. Braude</h2>
				<h3>
					<a href="http://isbndb.com/d/book/software_engineering_a09.html" target="_blank">
						Ingeniería De Software : Una Perspectiva Orientada A Objetos
					</a>
					Alfaomega, 2005.
				</h3>
				<h2></h2>
				<h2>Stephen Stelting, Olav Maassen</h2>
				<h3>
					<a href="http://isbndb.com/d/book/applied_java_patterns.html" target="_blank">
						Applied Java™ Patterns
					</a>
					Prentice Hall PTR, 2001.
				</h3>
				<div style="height:100px; width:100%;"></div>
			</div>

		</div>
	</div>

	<!--script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.7.2/jquery.min.js"></script-->
	<script src='js/jquery-1.8.2.min.js'></script>
	<script src='js/jquery-ui.js'></script>
	<script type="text/javascript" src="js/jquery.stellar.min.js"></script>
	<script type="text/javascript" src="js/waypoints.min.js"></script>
	<script type="text/javascript" src="js/jquery.easing.1.3.js"></script>
	<script type="text/javascript" src="js/scripts.js"></script>
	<script type="text/javascript" src="js/practice.js"></script>
	<script src='js/slides.js'></script>
	<!--link rel="stylesheet" type="text/css" href="styles.css"-->

	<!-- <script type="text/javascript" src="js/scripts.min.js"></script> -->
</body>
</html>
